JavaScripti Currying-tehnikad: Funktsionaalne Programmeerimine vs. Osaline Rakendamine

JavaScripti arendusmaailmas võib arenenud tehnikate, nagu currying, valdamine oluliselt parandada teie koodi loetavust, taaskasutatavust ja üldist hooldatavust. Currying, võimas kontseptsioon, mis pärineb funktsionaalsest programmeerimisest, võimaldab teil muuta mitut argumenti võtva funktsiooni funktsioonide jadaks, millest igaüks aktsepteerib ühte argumenti. See blogipostitus süveneb currying'u keerukustesse, võrreldes seda osalise rakendamisega ja pakkudes praktilisi näiteid selle eeliste illustreerimiseks.

Mis on Currying?

Currying on funktsiooni teisendus, mis muudab funktsiooni, mida saab kutsuda kujul f(a, b, c), kutsutavaks kujul f(a)(b)(c). Lihtsamalt öeldes ei võta curried-funktsioon kõiki argumente korraga. Selle asemel võtab see esimese argumendi ja tagastab uue funktsiooni, mis ootab teist argumenti, ja nii edasi, kuni kõik argumendid on edastatud ja lõpptulemus tagastatakse.

Kontseptsiooni Mõistmine

Kujutage ette funktsiooni, mis on mõeldud korrutamiseks:

            function multiply(a, b) {
  return a * b;
}
            

              
                Copy
              
            
          

Selle funktsiooni curried-versioon näeks välja selline:

            function curriedMultiply(a) {
  return function(b) {
    return a * b;
  }
}
            

              
                Copy
              
            
          

Nüüd saate seda kasutada nii:

            const multiplyByTwo = curriedMultiply(2);
console.log(multiplyByTwo(5)); // Väljund: 10

            

              
                Copy
              
            
          

Siin tagastab curriedMultiply(2) uue funktsiooni, mis mäletab a väärtust (mis on 2) ja ootab teist argumenti b. Kui kutsute välja multiplyByTwo(5), täidab see sisemise funktsiooni väärtustega a = 2 ja b = 5, mille tulemuseks on 10.

Currying vs. Osaline Rakendamine

Kuigi neid kasutatakse sageli sünonüümidena, on currying ja osaline rakendamine eraldiseisvad, kuid seotud mõisted. Peamine erinevus seisneb selles, kuidas argumente rakendatakse:

• Currying: Muudab mitme argumendiga funktsiooni pesastatud unaarsete (ühe argumendiga) funktsioonide jadaks. Iga funktsioon võtab täpselt ühe argumendi.
• Osaline rakendamine: Muudab funktsiooni, eeltäites mõned selle argumendid. See võib võtta korraga ühe või mitu argumenti ja tagastatud funktsioon peab endiselt aktsepteerima ülejäänud argumente.

Osalise Rakendamise Näide

            function greet(greeting, name) {
  return `${greeting}, ${name}!`;
}

function partialGreet(greeting) {
  return function(name) {
    return greet(greeting, name);
  }
}

const sayHello = partialGreet("Hello");
console.log(sayHello("Alice")); // Väljund: Hello, Alice!

            

              
                Copy
              
            
          

Selles näites võtab partialGreet argumendi greeting ja tagastab uue funktsiooni, mis ootab name'i. See on osaline rakendamine, kuna see ei muuda tingimata algset funktsiooni unaarsete funktsioonide jadaks.

Currying'u Näide

            function curryGreet(greeting) {
  return function(name) {
    return `${greeting}, ${name}!`;
  }
}

const currySayHello = curryGreet("Hello");
console.log(currySayHello("Bob")); // Väljund: Hello, Bob!

            

              
                Copy
              
            
          

Sel juhul võtab `curryGreet` ühe argumendi ja tagastab uue funktsiooni, mis võtab teise argumendi. Põhiline erinevus eelmisest näitest on peen, kuid oluline: currying muudab põhimõtteliselt funktsiooni struktuuri ühe argumendiga funktsioonide jadaks, samas kui osaline rakendamine ainult eeltäidab argumente.

Currying'u ja Osalise Rakendamise Eelised

Nii currying kui ka osaline rakendamine pakuvad JavaScripti arenduses mitmeid eeliseid:

• Koodi Taaskasutatavus: Looge spetsialiseeritud funktsioone üldisematest, eeltäites argumente.
• Parem Loetavus: Jaotage keerulised funktsioonid väiksemateks ja paremini hallatavateks osadeks.
• Suurem Paindlikkus: Kohandage funktsioone kergesti erinevate kontekstide ja stsenaariumitega.
• Argumentide Kordamise Vältimine: Vähendage korduvat koodi, taaskasutades eeltäidetud argumente.
• Funktsionaalne Kompositsioon: Hõlbustage keerukamate funktsioonide loomist, kombineerides lihtsamaid.

Currying'u ja Osalise Rakendamise Praktilised Näited

Uurime mõningaid praktilisi stsenaariume, kus currying ja osaline rakendamine võivad olla kasulikud.

1. Logimine Eelsätestatud Tasemetega

Kujutage ette, et peate logima sõnumeid erinevate raskusastmetega (nt INFO, WARN, ERROR). Saate kasutada osalist rakendamist, et luua spetsialiseeritud logimisfunktsioone:

            function log(level, message) {
  console.log(`[${level}] ${message}`);
}

function createLogger(level) {
  return function(message) {
    log(level, message);
  };
}

const logInfo = createLogger("INFO");
const logWarn = createLogger("WARN");
const logError = createLogger("ERROR");

logInfo("Rakendus käivitus edukalt.");
logWarn("Tuvastati vähe kettaruumi.");
logError("Andmebaasiga ühendumine ebaõnnestus.");

            

              
                Copy
              
            
          

See lähenemine võimaldab teil luua taaskasutatavaid logimisfunktsioone eelnevalt määratletud raskusastmetega, muutes teie koodi puhtamaks ja organiseeritumaks.

2. Numbrite Vormindamine Lokaadipõhiste Seadetega

Numbritega tegeledes peate neid sageli vormindama vastavalt konkreetsetele lokaatidele (nt kasutades erinevaid komakohti eraldajaid või valuutasümboleid). Saate kasutada currying'ut, et luua funktsioone, mis vormindavad numbreid kasutaja lokaadi alusel:

            function formatNumber(locale) {
  return function(number) {
    return number.toLocaleString(locale);
  };
}

const formatGermanNumber = formatNumber("de-DE");
const formatUSNumber = formatNumber("en-US");

console.log(formatGermanNumber(1234.56)); // Väljund: 1.234,56
console.log(formatUSNumber(1234.56));   // Väljund: 1,234.56

            

              
                Copy
              
            
          

See näide demonstreerib, kuidas currying'ut saab kasutada funktsioonide loomiseks, mis kohanduvad erinevate kultuuriliste seadetega, muutes teie rakenduse globaalsele publikule kasutajasõbralikumaks.

3. Dünaamiliste Päringustringide Koostamine

Dünaamiliste päringustringide loomine on API-dega suhtlemisel tavaline ülesanne. Currying aitab teil neid stringe ehitada elegantsemal ja hooldatavamal viisil:

            function buildQueryString(baseUrl) {
  return function(params) {
    const queryString = Object.entries(params)
      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
      .join('&');
    return `${baseUrl}?${queryString}`;
  };
}

const createApiUrl = buildQueryString("https://api.example.com/data");

const apiUrl = createApiUrl({
  page: 1,
  limit: 20,
  sort: "name"
});

console.log(apiUrl); // Väljund: https://api.example.com/data?page=1&limit=20&sort=name

            

              
                Copy
              
            
          

See näide näitab, kuidas currying'ut saab kasutada funktsiooni loomiseks, mis genereerib dünaamiliste päringuparameetritega API URL-e.

4. Sündmuste Käsitlemine Veebirakendustes

Currying võib olla uskumatult kasulik sündmuste käsitlejate loomisel veebirakendustes. Eelseadistades sündmuse käsitleja konkreetsete andmetega, saate vähendada korduva koodi hulka ja muuta oma sündmuste käsitlemise loogika lühemaks.

            function handleClick(elementId, message) {
  return function(event) {
    const element = document.getElementById(elementId);
    if (element) {
      element.textContent = message;
    }
  };
}

const button = document.getElementById('myButton');
if (button) {
  button.addEventListener('click', handleClick('myButton', 'Nupule klõpsati!'));
}

            

              
                Copy
              
            
          

Selles näites on `handleClick` curried-funktsioon, mis aktsepteerib elemendi ID ja sõnumi ette, tagastades funktsiooni, mis seejärel lisatakse sündmuse kuulajana. See muster muudab koodi loetavamaks ja taaskasutatavamaks, eriti keerulistes veebirakendustes.

Currying'u Rakendamine JavaScriptis

JavaScriptis on currying'u rakendamiseks mitu viisi. Saate käsitsi luua curried-funktsioone, nagu on näidatud ülaltoodud näidetes, või kasutada protsessi automatiseerimiseks abifunktsioone.

Käsitsi Currying

Nagu eelnevates näidetes demonstreeritud, hõlmab käsitsi currying pesastatud funktsioonide loomist, millest igaüks aktsepteerib ühte argumenti. See lähenemine annab peeneteralise kontrolli currying-protsessi üle, kuid võib olla paljude argumentidega funktsioonide puhul sõnarohke.

Currying'u Abifunktsiooni Kasutamine

Currying-protsessi lihtsustamiseks saate luua abifunktsiooni, mis teisendab funktsiooni automaatselt selle curried-ekvivalendiks. Siin on näide currying'u abifunktsioonist:

            function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

            

              
                Copy
              
            
          

See curry-funktsioon võtab sisendiks funktsiooni fn ja tagastab selle funktsiooni curried-versiooni. See töötab, kogudes rekursiivselt argumente, kuni kõik algse funktsiooni jaoks vajalikud argumendid on edastatud. Kui kõik argumendid on saadaval, käivitab see algse funktsiooni nende argumentidega.

Siin on, kuidas saate curry-abifunktsiooni kasutada:

            function add(a, b, c) {
  return a + b + c;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3));     // Väljund: 6
console.log(curriedAdd(1, 2)(3));   // Väljund: 6
console.log(curriedAdd(1)(2, 3));   // Väljund: 6
console.log(curriedAdd(1, 2, 3));   // Väljund: 6

            

              
                Copy
              
            
          

Teekide nagu Lodash Kasutamine

Teegid nagu Lodash pakuvad sisseehitatud funktsioone currying'u jaoks, muutes selle tehnika rakendamise oma projektides veelgi lihtsamaks. Lodashi _.curry-funktsioon töötab sarnaselt ülalpool kirjeldatud abifunktsiooniga, kuid pakub ka lisavõimalusi ja -funktsioone.

            const _ = require('lodash');

function multiply(a, b, c) {
  return a * b * c;
}

const curriedMultiply = _.curry(multiply);

console.log(curriedMultiply(2)(3)(4));   // Väljund: 24
console.log(curriedMultiply(2, 3)(4)); // Väljund: 24

            

              
                Copy
              
            
          

Täiustatud Currying-tehnikad

Lisaks currying'u põhirakendusele on mitmeid täiustatud tehnikaid, mis võivad teie koodi paindlikkust ja väljendusrikkust veelgi parandada.

Kohatäite Argumendid

Kohatäite argumendid võimaldavad teil määrata järjekorra, milles argumente curried-funktsioonile rakendatakse. See võib olla kasulik, kui soovite mõned argumendid eeltäita, kuid jätta teised hilisemaks.

            const _ = require('lodash');

function divide(a, b) {
  return a / b;
}

const curriedDivide = _.curry(divide);

const divideBy = curriedDivide(_.placeholder, 2); // Kohatäide esimesele argumendile

console.log(divideBy(10)); // Väljund: 5

            

              
                Copy
              
            
          

Selles näites kasutatakse _.placeholder'it, et näidata, et esimene argument täidetakse hiljem. See võimaldab teil luua funktsiooni divideBy, mis jagab arvu kahega, sõltumata sellest, millises järjekorras argumendid on esitatud.

Automaatne Currying

Automaatne currying on tehnika, kus funktsioon teostab currying'ut automaatselt vastavalt esitatud argumentide arvule. Kui funktsioon saab kõik vajalikud argumendid, käivitub see kohe. Vastasel juhul tagastab see uue funktsiooni, mis ootab ülejäänud argumente.

            function autoCurry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return (...args2) => curried(...args, ...args2);
    }
  };
}

function greet(greeting, name) {
  return `${greeting}, ${name}!`;
}

const autoCurriedGreet = autoCurry(greet);

console.log(autoCurriedGreet("Hello", "World")); // Väljund: Hello, World!
console.log(autoCurriedGreet("Hello")("World")); // Väljund: Hello, World!

            

              
                Copy
              
            
          

See autoCurry-funktsioon tegeleb currying-protsessiga automaatselt, võimaldades teil funktsiooni kutsuda kas kõigi argumentidega korraga või mitme kutse seeriana.

Levinud Lõksud ja Parimad Praktikad

Kuigi currying võib olla võimas tehnika, on oluline olla teadlik potentsiaalsetest lõksudest ja järgida parimaid praktikaid, et tagada koodi loetavus ja hooldatavus.

• Liigne Currying: Vältige funktsioonide asjatut currying'ut. Kasutage currying'ut ainult siis, kui see annab selge eelise taaskasutatavuse või loetavuse osas.
• Keerukus: Currying võib teie koodile lisada keerukust, eriti kui seda ei kasutata läbimõeldult. Veenduge, et currying'u eelised kaaluvad üles lisandunud keerukuse.
• Silumine: Curried-funktsioonide silumine võib olla keeruline, kuna täitmise voog võib olla vähem sirgjooneline. Kasutage silumistööriistu ja -tehnikaid, et mõista, kuidas argumente rakendatakse ja kuidas funktsiooni täidetakse.
• Nimekonventsioonid: Kasutage curried-funktsioonide ja nende vahetulemuste jaoks selgeid ja kirjeldavaid nimesid. See aitab teistel arendajatel (ja teie tulevasel minal) mõista iga funktsiooni eesmärki ja kasutusviisi.
• Dokumentatsioon: Dokumenteerige oma curried-funktsioonid põhjalikult, selgitades iga argumendi eesmärki ja funktsiooni oodatavat käitumist.

Kokkuvõte

Currying ja osaline rakendamine on väärtuslikud tehnikad JavaScriptis, mis võivad parandada teie koodi loetavust, taaskasutatavust ja paindlikkust. Mõistes nende kontseptsioonide erinevusi ja rakendades neid asjakohaselt, saate kirjutada puhtamat, hooldatavamat koodi, mida on lihtsam testida ja siluda. Olenemata sellest, kas ehitate keerulisi veebirakendusi või lihtsaid abifunktsioone, currying'u ja osalise rakendamise valdamine tõstab kahtlemata teie JavaScripti oskusi ja teeb teist tõhusama arendaja. Pidage meeles arvestada oma projekti konteksti, kaaluda eeliseid ja võimalikke puudusi ning järgida parimaid praktikaid, et tagada, et currying pigem parandab kui takistab teie koodi kvaliteeti.

Funktsionaalse programmeerimise põhimõtete omaksvõtmisega ja tehnikate nagu currying rakendamisega saate avada uusi väljendusrikkuse ja elegantsi tasemeid oma JavaScripti koodis. Jätkates JavaScripti arendusmaailma avastamist, kaaluge currying'u ja osalise rakendamisega katsetamist oma projektides ning avastage, kuidas need tehnikad aitavad teil kirjutada paremat ja hooldatavamat koodi.